package JDK91011;

import com.sun.jdi.IntegerType;
import org.junit.jupiter.api.Test;

import java.io.*;
import java.util.*;
import java.util.stream.Stream;

/**
 * @author Lenl
 * @version v1.0
 * @create 2021-06-08 21:11
 * @description java9的一些特性
 */
public class Java9Test {
    //java9特性6: try操作的升级
    @Test
    public void test1(){
        //java8
        try(InputStreamReader reader=new InputStreamReader(System.in)){
            reader.ready();
            //java8可以实现资源的自动关闭
        }catch (Exception e){
            e.printStackTrace();
        }
        //java9
        InputStreamReader reader1=new InputStreamReader(System.in);
        try(reader1){
            //java9资源的声明可以在外部。但变成了常量，不可修改，多个流用 ; 隔开
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    //java9新特性8：集合工厂方法：创建只读集合
    //java8的写法：
    @Test
    public void test2(){
        List<String> nameList=new ArrayList<>();
        nameList.add("Joe");
        nameList.add("Bob");
        nameList.add("Bill");
        nameList= Collections.unmodifiableList(nameList);
        //获得了只读的集合

       // nameList.add("Tom");//编译不报错，运行会报错

        System.out.println(nameList);
    }
    @Test
    public void test3(){
        List<String> list=Collections.unmodifiableList(Arrays.asList("a","b","c"));
        Set<String> set =Collections.unmodifiableSet(new HashSet<>(Arrays.asList("1","2","3","4","5")));
        //如下操作不适用于jdk8及以前版本
        Map<String,Integer> map=Collections.unmodifiableMap(new HashMap<>(){
            {
                put("a",1);
                put("b",2);
                put("c",3);
            }
        });
        map.forEach((k,v)-> System.out.println(k+":"+v));

        //List<Integer> list1=Arrays.asList(1,2,3,4);//这样定义也是只读的
    }
    //java9引入的更方便的写法
    @Test
    public void  test4(){
        List<Integer> list=List.of(1,2,3,4,5);
        Set<Integer> set=Set.of(1,2,3,4,5);
        Map<String, Integer> map=Map.of("tom",12,"zhansan",22);
        Map<String,Integer> map2=Map.ofEntries(Map.entry("tom",12),Map.entry("za",13));
    }

    //java特性9：InputStream的新方法transferTo()
    @Test
    public void test5(){
        ClassLoader c1=this.getClass().getClassLoader();
        try(InputStream is=c1.getResourceAsStream("hello.txt");
            OutputStream os=new FileOutputStream("hello1.txt")){
            is.transferTo(os);//把输入流的所有数据直接自动地复制到输出流

        }catch (IOException e){
            e.printStackTrace();
        }

    }

    //java9新特性10：StreamApi增强，四个方法
    @Test
    public void test6(){
        List<Integer> list=Arrays.asList(12,23,43,45,61,54,32,3,2,89,7,45);
        //takeWhile 返回从开头开始按制定规则尽可能多的元素
        list.stream().takeWhile(t->t<60).forEach(System.out::println);
        //dropWhile 与takeWhile相反，返回从不满足要求起后面的元素
        list.stream().dropWhile(t->t<60).forEach(System.out::println);
    }
    @Test
    public void test7(){
        Stream<Integer> stream1=Stream.of(1,2,3,null);
        stream1.forEach(System.out::println);
        //但是不能只填充一个null，但可以多个null。

        //ofNullable只能一个元素，可以为null
        Stream<Object> objectStream = Stream.ofNullable(null);
        System.out.println(objectStream.count());
        //objectStream.forEach(System.out::println);
    }
    @Test
    public void test8(){
        //无限流
        Stream.iterate(0,x->x+1).limit(10).forEach(System.out::println);

        //java9中新增的重载方法
        Stream.iterate(0,t->t<20,t->t+1).forEach(System.out::println);
    }

    //java9新特性十一：Optional提供了新的方法stream()
    @Test
    public void test9(){
        List<String> list=new ArrayList<>();
        list.add("Tom");
        list.add("Jerry");
        list.add("Jim");

        Optional<List<String>> optional=Optional.of(list);
        Stream<List<String>> stream=optional.stream();
        stream.flatMap(x->x.stream()).forEach(System.out::println);

    }


}
